package display3D.objet3D
{
	import Tools.Geometry;
	
	import alternativa.engine3d.core.Clipping;
	import alternativa.engine3d.core.MipMapping;
	import alternativa.engine3d.core.Object3D;
	import alternativa.engine3d.core.Object3DContainer;
	import alternativa.engine3d.core.Sorting;
	import alternativa.engine3d.core.Vertex;
	import alternativa.engine3d.materials.FillMaterial;
	import alternativa.engine3d.materials.TextureMaterial;
	import alternativa.engine3d.objects.Mesh;
	import alternativa.engine3d.primitives.Box;
	
	import display3D.embed.Texture;
	
	import flash.events.EventDispatcher;
	
	import mx.controls.Alert;

	/**
	 * Classe représentant une transition dans la salle 3D
	 * @author Arnaud
	 */
	public class Transition extends EventDispatcher
	{
		/**
		 * Longueur du couloir
		 * @default 1000
		 */
		private static var longueurCouloir:int = 1000;
		/**
		 * Largeur du couloir
		 * @default 80
		 */
		private static var largeurCouloir:int = 160;
		/**
		 * Longueur de l'ascenseur
		 * @default 400
		 */
		private static var longueurAscenseur:int = 400;
		/**
		 * Largeur de l'ascenseur
		 * @default 200
		 */
		private static var largeurAscenseur:int = 200;
		private var _id:String;
		private var _charged:Boolean;
		private var _pointX:*;
		private var _pointY:*;
		private var _vecteurNormMur:Array;
		private var _objet3D:Vector.<Object3D>;
		private var _pointContact:Array;
		private var _pointContact2:Array;
		private var _entrer:Boolean;
		
		
		/**
		 * Contructeur
		 */
		public function Transition()
		{
			_charged=false;
			_objet3D = new Vector.<Object3D>;
			_pointContact = new Array;
			_pointContact2 = new Array;
			_entrer = true;
		}

		
		/**
		 * Dessine la transition sur la scene
		 * @param scene Conteneur de notre salle3D
		 * @param vectNormMur Vecteur normalisé du mur qui contient la transition
		 * @param x Coordonée x du milieu de la porte
		 * @param y Coordonnée y du milieu de la porte
		 */
		public function draw(scene:Object3DContainer,vectNormMur:Array,x:*,y:*):void
		{
			if (this._id == "couloir")
			{
				drawCouloir(scene,vectNormMur,x,y);
			}
			else if (this._id == "ascenseur")
			{
				drawAscenseur(scene,vectNormMur,x,y);
			}
			
		}
		
		/**
		 * Dessine la transition ascenseur
		 * @param scene Conteneur de notre salle3D
		 * @param vectNormMur Vecteur normalisé du mur qui contient la transition
		 * @param x Coordonée x du milieu de la porte
		 * @param y Coordonnée y du milieu de la porte
		 */
		private function drawAscenseur(scene:Object3DContainer,vectNormMur:Array,x:*,y:*)
		{
			this._vecteurNormMur = vectNormMur;
			//Calcul des coordonnees
			var point1:Array = new Array;
			var point2:Array = new Array;
			
			point1[0] = x -(vectNormMur[0]*longueurAscenseur);
			point1[1] = y -(vectNormMur[1]*longueurAscenseur);
			
			point2[0] = x +(vectNormMur[0]*longueurAscenseur);
			point2[1] = y +(vectNormMur[1]*longueurAscenseur);
			
			var distM:* = Geometry.distance(point1[0],point1[1],point2[0],point2[1]);
			
			//Vecteur perpendiculaire au mur
			var vPer:Array = new Array;
			vPer[0] = (point1[1] - point2[1]);
			vPer[1] = -(point1[0] - point2[0]); 
			
			
			
			//Vecteur normalisé perpendiculaire
			var vNper:Array = new Array;
			vNper[0] = vPer[0]/distM;
			vNper[1] = vPer[1]/distM;	
			
			//On rempli le point de transition
			this._pointX = x +vNper[0]*longueurAscenseur;
			this._pointY = y +vNper[1]*longueurAscenseur;
			
			//Texture de la partir Mur
			var textureM:TextureMaterial = new TextureMaterial(new (display3D.embed.Texture.EmbedTextureMurAscenseur)().bitmapData, false, true, MipMapping.PER_PIXEL);
			textureM.correctUV =true;
			
			//Mur 
			var meshp:Mesh = new Mesh;
			var v1p:Vertex = meshp.addVertex(point1[0], point1[1], Mur.hauteur, 0, 0, "v1p");
			var v2p:Vertex = meshp.addVertex(point1[0], point1[1], 0, 0, 1, "v2p");
			var v3p:Vertex = meshp.addVertex(point1[0]+vNper[0]*longueurAscenseur, point1[1]+vNper[1]*longueurAscenseur, 0, 1, 1, "v3p");
			var v4p:Vertex = meshp.addVertex(point1[0]+vNper[0]*longueurAscenseur, point1[1]+vNper[1]*longueurAscenseur,  Mur.hauteur, 1, 0, "v4p");
			meshp.addQuadFace(v1p,v2p,v3p,v4p, textureM,"facePorte2");
			meshp.addQuadFace(v4p,v3p,v2p,v1p, textureM,"facePorte2");
			meshp.calculateFacesNormals(true);
			meshp.clipping = Sorting.DYNAMIC_BSP;
			meshp.calculateBounds();
			
			//Mur
			var meshd:Mesh = new Mesh;
			var v1d:Vertex = meshd.addVertex(point2[0], point2[1], Mur.hauteur, 0, 0, "v1p");
			var v2d:Vertex = meshd.addVertex(point2[0], point2[1], 0, 0, 1, "v2p");
			var v3d:Vertex = meshd.addVertex(point2[0]+vNper[0]*longueurAscenseur, point2[1]+vNper[1]*longueurAscenseur, 0, 1, 1, "v3p");
			var v4d:Vertex = meshd.addVertex(point2[0]+vNper[0]*longueurAscenseur, point2[1]+vNper[1]*longueurAscenseur,  Mur.hauteur, 1, 0, "v4p");
			meshd.addQuadFace(v1d,v2d,v3d,v4d, textureM,"facePorte2");
			meshd.addQuadFace(v4d,v3d,v2d,v1d, textureM,"facePorte2");
			meshd.calculateFacesNormals(true);
			meshd.clipping = Sorting.DYNAMIC_BSP;
			meshd.calculateBounds();
			
			//Plafond
			
			
			var meshz:Mesh = new Mesh;
			var v1z:Vertex = meshz.addVertex(point1[0], point1[1], Mur.hauteur-200, 0, 0, "v1p");
			var v2z:Vertex = meshz.addVertex(point2[0], point2[1], Mur.hauteur-200, 0, 1, "v2p");
			var v3z:Vertex = meshz.addVertex(point2[0]+vNper[0]*longueurAscenseur, point2[1]+vNper[1]*longueurAscenseur,  Mur.hauteur-200, 1, 1, "v4p");
			var v4z:Vertex = meshz.addVertex(point1[0]+vNper[0]*longueurAscenseur, point1[1]+vNper[1]*longueurAscenseur, Mur.hauteur-200, 1, 0, "v3p");
			
			meshz.addQuadFace(v1z,v2z,v3z,v4z, null,"facePorte2");
			meshz.addQuadFace(v4z,v3z,v2z,v1z, null,"facePorte2");
			meshz.calculateFacesNormals(true);
			meshz.clipping = Sorting.DYNAMIC_BSP;
			meshz.calculateBounds();
			meshz.setMaterialToAllFaces(new FillMaterial(0xFFFFFF));
			
			//Sol
			var textureS:TextureMaterial = new TextureMaterial(new (display3D.embed.Texture.EmbedTextureSolAscenseur)().bitmapData, false, true, MipMapping.PER_PIXEL);
			textureM.correctUV =true;
			
			var meshs:Mesh = new Mesh;
			var v1s:Vertex = meshs.addVertex(point1[0], point1[1], 1, 0, 0, "v1p");
			var v2s:Vertex = meshs.addVertex(point2[0], point2[1], 1, 0, 1, "v2p");
			var v3s:Vertex = meshs.addVertex(point2[0]+vNper[0]*longueurAscenseur, point2[1]+vNper[1]*longueurAscenseur,  1, 1, 1, "v4p");
			var v4s:Vertex = meshs.addVertex(point1[0]+vNper[0]*longueurAscenseur, point1[1]+vNper[1]*longueurAscenseur, 1, 1, 0, "v3p");
			
			meshs.addQuadFace(v1s,v2s,v3s,v4s, null,"facePorte2");
			meshs.addQuadFace(v4s,v3s,v2s,v1s, null,"facePorte2");
			meshs.calculateFacesNormals(true);
			meshs.clipping = Sorting.DYNAMIC_BSP;
			meshs.calculateBounds();
			meshs.setMaterialToAllFaces(textureS);
			
			//Calcul des coordonnees
			var point1b:Array = new Array;
			var point2b:Array = new Array;
			
			point1b[0] = point1[0] +(vNper[0]*longueurAscenseur);
			point1b[1] = point1[1] + (vNper[1]*longueurAscenseur);
			
			point2b[0] = point2[0] +(vNper[0]*longueurAscenseur);
			point2b[1] = point2[1] +(vNper[1]*longueurAscenseur);
			
			//Calcul de la partie mur	
			var meshmx:Mesh = new Mesh();
			var v1mx:Vertex = meshmx.addVertex(point1b[0], point1b[1],  Mur.hauteur, 0, 0, "v1m");
			var v2mx:Vertex = meshmx.addVertex(point1b[0], point1b[1], 0, 0, 1, "v2m");
			var v3mx:Vertex = meshmx.addVertex(point2b[0], point2b[1], 0, 1, 1, "v3m");
			var v4mx:Vertex = meshmx.addVertex(point2b[0], point2b[1],  Mur.hauteur, 1, 0, "v4m");
			meshmx.addQuadFace(v4mx,v3mx,v2mx,v1mx, textureM,"faceMur1");
			meshmx.addQuadFace(v1mx,v2mx,v3mx,v4mx, textureM,"faceMur2");
			meshmx.calculateFacesNormals(true);
			meshmx.clipping = Clipping.FACE_CLIPPING;
			meshmx.sorting = Sorting.DYNAMIC_BSP;
			meshmx.calculateBounds();
			
			scene.addChild(meshp);
			scene.addChild(meshd);
			scene.addChild(meshz);
			scene.addChild(meshs);
			scene.addChild(meshmx);
			_objet3D.push(meshz,meshd,meshp,meshs,meshmx);
			
			pointContactsAscenseur(scene,vectNormMur,vNper,x,y);
			this._charged = true;
		}
		
		/**
		 * Dessine la transition couloir
		 * @param scene Conteneur de notre salle3D
		 * @param vectNormMur Vecteur normalisé du mur qui contient la transition
		 * @param x Coordonée x du milieu de la porte
		 * @param y Coordonnée y du milieu de la porte
		 */
		private function drawCouloir(scene:Object3DContainer,vectNormMur:Array,x:*,y:*)
		{
			this._vecteurNormMur = vectNormMur;
			//Calcul des coordonnees
			var point1:Array = new Array;
			var point2:Array = new Array;
			
			point1[0] = x -(vectNormMur[0]*largeurCouloir/2);
			point1[1] = y -(vectNormMur[1]*largeurCouloir/2);
			
			point2[0] = x +(vectNormMur[0]*largeurCouloir/2);
			point2[1] = y +(vectNormMur[1]*largeurCouloir/2);
			
			var distM:* = Geometry.distance(point1[0],point1[1],point2[0],point2[1]);
			
			//Vecteur perpendiculaire au mur
			var vPer:Array = new Array;
			vPer[0] = (point1[1] - point2[1]);
			vPer[1] = -(point1[0] - point2[0]); 
			
			
			
			//Vecteur normalisé perpendiculaire
			var vNper:Array = new Array;
			vNper[0] = vPer[0]/distM;
			vNper[1] = vPer[1]/distM;	
			
			//On rempli le point de transition
			this._pointX = x +vNper[0]*longueurCouloir;
			this._pointY = y +vNper[1]*longueurCouloir;
			
			//Texture de la partir Mur
			var textureM:TextureMaterial = new TextureMaterial(new (display3D.embed.Texture.EmbedTextureMurCouloir)().bitmapData, false, true, MipMapping.PER_PIXEL);
			textureM.correctUV =true;
			
			//Mur 
			var meshp:Mesh = new Mesh;
			var v1p:Vertex = meshp.addVertex(point1[0], point1[1], Mur.hauteur, 0, 0, "v1p");
			var v2p:Vertex = meshp.addVertex(point1[0], point1[1], 0, 0, 1, "v2p");
			var v3p:Vertex = meshp.addVertex(point1[0]+vNper[0]*longueurCouloir, point1[1]+vNper[1]*longueurCouloir, 0, 1, 1, "v3p");
			var v4p:Vertex = meshp.addVertex(point1[0]+vNper[0]*longueurCouloir, point1[1]+vNper[1]*longueurCouloir,  Mur.hauteur, 1, 0, "v4p");
			meshp.addQuadFace(v1p,v2p,v3p,v4p, textureM,"facePorte2");
			meshp.addQuadFace(v4p,v3p,v2p,v1p, textureM,"facePorte2");
			meshp.calculateFacesNormals(true);
			meshp.clipping = Sorting.DYNAMIC_BSP;
			meshp.calculateBounds();
			
			//Mur
			var meshd:Mesh = new Mesh;
			var v1d:Vertex = meshd.addVertex(point2[0], point2[1], Mur.hauteur, 0, 0, "v1p");
			var v2d:Vertex = meshd.addVertex(point2[0], point2[1], 0, 0, 1, "v2p");
			var v3d:Vertex = meshd.addVertex(point2[0]+vNper[0]*longueurCouloir, point2[1]+vNper[1]*longueurCouloir, 0, 1, 1, "v3p");
			var v4d:Vertex = meshd.addVertex(point2[0]+vNper[0]*longueurCouloir, point2[1]+vNper[1]*longueurCouloir,  Mur.hauteur, 1, 0, "v4p");
			meshd.addQuadFace(v1d,v2d,v3d,v4d, textureM,"facePorte2");
			meshd.addQuadFace(v4d,v3d,v2d,v1d, textureM,"facePorte2");
			meshd.calculateFacesNormals(true);
			meshd.clipping = Sorting.DYNAMIC_BSP;
			meshd.calculateBounds();
			
			//Plafond
			
			
			var meshz:Mesh = new Mesh;
			var v1z:Vertex = meshz.addVertex(point1[0], point1[1], Mur.hauteur-250, 0, 0, "v1p");
			var v2z:Vertex = meshz.addVertex(point2[0], point2[1], Mur.hauteur-250, 0, 1, "v2p");
			var v3z:Vertex = meshz.addVertex(point2[0]+vNper[0]*longueurCouloir, point2[1]+vNper[1]*longueurCouloir,  Mur.hauteur-250, 1, 1, "v4p");
			var v4z:Vertex = meshz.addVertex(point1[0]+vNper[0]*longueurCouloir, point1[1]+vNper[1]*longueurCouloir, Mur.hauteur-250, 1, 0, "v3p");
			
			meshz.addQuadFace(v1z,v2z,v3z,v4z, null,"facePorte2");
			meshz.addQuadFace(v4z,v3z,v2z,v1z, null,"facePorte2");
			meshz.calculateFacesNormals(true);
			meshz.clipping = Sorting.DYNAMIC_BSP;
			meshz.calculateBounds();
			meshz.setMaterialToAllFaces(new FillMaterial(0xFFFFFF));
			
			//Sol
			var textureS:TextureMaterial = new TextureMaterial(new (display3D.embed.Texture.EmbedTextureSolCouloir)().bitmapData, false, true, MipMapping.PER_PIXEL);
			textureM.correctUV =true;
			
			var meshs:Mesh = new Mesh;
			var v1s:Vertex = meshs.addVertex(point1[0], point1[1], 1, 0, 0, "v1p");
			var v2s:Vertex = meshs.addVertex(point2[0], point2[1], 1, 0, 1, "v2p");
			var v3s:Vertex = meshs.addVertex(point2[0]+vNper[0]*longueurCouloir, point2[1]+vNper[1]*longueurCouloir,  1, 1, 1, "v4p");
			var v4s:Vertex = meshs.addVertex(point1[0]+vNper[0]*longueurCouloir, point1[1]+vNper[1]*longueurCouloir, 1, 1, 0, "v3p");
			
			meshs.addQuadFace(v1s,v2s,v3s,v4s, null,"facePorte2");
			meshs.addQuadFace(v4s,v3s,v2s,v1s, null,"facePorte2");
			meshs.calculateFacesNormals(true);
			meshs.clipping = Sorting.DYNAMIC_BSP;
			meshs.calculateBounds();
			meshs.setMaterialToAllFaces(textureS);
			
			//Porte fictive
			
			scene.addChild(meshp);
			scene.addChild(meshd);
			scene.addChild(meshz);
			scene.addChild(meshs);
			_objet3D.push(meshz,meshd,meshp,meshs);
			
			drawPorteFictive(scene,vectNormMur,vNper,x,y);
			pointContacts(scene,vectNormMur,vNper,x,y);
			this._charged = true;
		}
		
		/**
		 * Créer les point de contact pour la transition couloir
		 * @param scene Conteneur de notre salle3D
		 * @param vectNormMur Vecteur normalisé du mur qui contient la transition
		 * @param vectNormCouloir Vecteur normalisé des mur du couloir
		 * @param x Coordonée x du milieu de la porte
		 * @param y Coordonnée y du milieu de la porte
		 */
		private function pointContacts(scene:Object3DContainer,vectNormMur:Array,vectNormCouloir:Array,x:*,y:*):void
		{
			//Calcul des coordonnees
			var point1p:Array = new Array;
			var point2p:Array = new Array;
			var point1:Array = new Array;
			var point2:Array = new Array;
			
			point1p[0] = x -(vectNormMur[0]*Porte.taillePorte/2);
			point1p[1] = y -(vectNormMur[1]*Porte.taillePorte/2);
			
			point2p[0] = x +(vectNormMur[0]*Porte.taillePorte/2);
			point2p[1] = y +(vectNormMur[1]*Porte.taillePorte/2);
			
			point1[0] = point1p[0] +(vectNormCouloir[0]*longueurAscenseur);
			point1[1] = point1p[1] + (vectNormCouloir[1]*longueurAscenseur);
			
			point2[0] = point2p[0] +(vectNormCouloir[0]*longueurAscenseur);
			point2[1] = point2p[1] +(vectNormCouloir[1]*longueurAscenseur);
			
			this._pointContact[0] = point1;
			this._pointContact[1] = point2;
			
			//Calcul des coordonnees
			var point1pb:Array = new Array;
			var point2pb:Array = new Array;
			var point1b:Array = new Array;
			var point2b:Array = new Array;
			
			point1pb[0] = x -(vectNormMur[0]*Porte.taillePorte/2);
			point1pb[1] = y -(vectNormMur[1]*Porte.taillePorte/2);
			
			point2pb[0] = x +(vectNormMur[0]*Porte.taillePorte/2);
			point2pb[1] = y +(vectNormMur[1]*Porte.taillePorte/2);
			
			point1b[0] = point1pb[0] +(vectNormCouloir[0]);
			point1b[1] = point1pb[1] + (vectNormCouloir[1]);
			
			point2b[0] = point2pb[0] +(vectNormCouloir[0]);
			point2b[1] = point2pb[1] +(vectNormCouloir[1]);
			
			this._pointContact2[0] = point1b;
			this._pointContact2[1] = point2b;
			
		}
		
		/**
		 * Créer les point de contact pour la transition ascenseur
		 * @param scene Conteneur de notre salle3D
		 * @param vectNormMur Vecteur normalisé du mur qui contient la transition
		 * @param vectNormCouloir Vecteur normalisé des mur de l'ascenseur
		 * @param x Coordonée x du milieu de la porte
		 * @param y Coordonnée y du milieu de la porte
		 */
		private function pointContactsAscenseur(scene:Object3DContainer,vectNormMur:Array,vectNormCouloir:Array,x:*,y:*):void
		{
			//Calcul des coordonnees
			var point1p:Array = new Array;
			var point2p:Array = new Array;
			var point1:Array = new Array;
			var point2:Array = new Array;
			
			point1p[0] = x -(vectNormMur[0]*Porte.taillePorte/2);
			point1p[1] = y -(vectNormMur[1]*Porte.taillePorte/2);
			
			point2p[0] = x +(vectNormMur[0]*Porte.taillePorte/2);
			point2p[1] = y +(vectNormMur[1]*Porte.taillePorte/2);
			
			point1[0] = point1p[0] +(vectNormCouloir[0]*longueurAscenseur);
			point1[1] = point1p[1] + (vectNormCouloir[1]*longueurAscenseur);
			
			point2[0] = point2p[0] +(vectNormCouloir[0]*longueurAscenseur);
			point2[1] = point2p[1] +(vectNormCouloir[1]*longueurAscenseur);
			
			this._pointContact[0] = point1;
			this._pointContact[1] = point2;
			
			//Calcul des coordonnees
			var point1pb:Array = new Array;
			var point2pb:Array = new Array;
			var point1b:Array = new Array;
			var point2b:Array = new Array;
			
			point1pb[0] = x -(vectNormMur[0]*Porte.taillePorte/2);
			point1pb[1] = y -(vectNormMur[1]*Porte.taillePorte/2);
			
			point2pb[0] = x +(vectNormMur[0]*Porte.taillePorte/2);
			point2pb[1] = y +(vectNormMur[1]*Porte.taillePorte/2);
			
			point1b[0] = point1pb[0] +(vectNormCouloir[0]);
			point1b[1] = point1pb[1] + (vectNormCouloir[1]);
			
			point2b[0] = point2pb[0] +(vectNormCouloir[0]);
			point2b[1] = point2pb[1] +(vectNormCouloir[1]);
			
			this._pointContact2[0] = point1b;
			this._pointContact2[1] = point2b;
			
		}
		
		
		/**
		 * Dessine la porte fictive au fond du couloir
		 * @param scene Conteneur de notre salle3D
		 * @param vectNormMur Vecteur normalisé du mur qui contient la transition
		 * @param vectNormCouloir Vecteur normalisé des mur du couloir
		 * @param x Coordonée x du milieu de la porte
		 * @param y Coordonnée y du milieu de la porte
		 */
		private function drawPorteFictive(scene:Object3DContainer,vectNormMur:Array,vectNormCouloir:Array,x:*,y:*):void
		{
			//Calcul des coordonnees
			var point1p:Array = new Array;
			var point2p:Array = new Array;
			var point1:Array = new Array;
			var point2:Array = new Array;
			
			point1p[0] = x -(vectNormMur[0]*Porte.taillePorte/2);
			point1p[1] = y -(vectNormMur[1]*Porte.taillePorte/2);
			
			point2p[0] = x +(vectNormMur[0]*Porte.taillePorte/2);
			point2p[1] = y +(vectNormMur[1]*Porte.taillePorte/2);
			
			point1[0] = point1p[0] +(vectNormCouloir[0]*longueurCouloir);
			point1[1] = point1p[1] + (vectNormCouloir[1]*longueurCouloir);
			
			point2[0] = point2p[0] +(vectNormCouloir[0]*longueurCouloir);
			point2[1] = point2p[1] +(vectNormCouloir[1]*longueurCouloir);
			
			
			//Calcul des coordonnees
			var point1pb:Array = new Array;
			var point2pb:Array = new Array;
			var point1b:Array = new Array;
			var point2b:Array = new Array;
			
			point1pb[0] = x -(vectNormMur[0]*largeurCouloir/2);
			point1pb[1] = y -(vectNormMur[1]*largeurCouloir/2);
			
			point2pb[0] = x +(vectNormMur[0]*largeurCouloir/2);
			point2pb[1] = y +(vectNormMur[1]*largeurCouloir/2);
			
			point1b[0] = point1pb[0] +(vectNormCouloir[0]*longueurCouloir);
			point1b[1] = point1pb[1] + (vectNormCouloir[1]*longueurCouloir);
			
			point2b[0] = point2pb[0] +(vectNormCouloir[0]*longueurCouloir);
			point2b[1] = point2pb[1] +(vectNormCouloir[1]*longueurCouloir);
			
			
			//Texture de la partir Mur
			var textureM:TextureMaterial = new TextureMaterial(new (display3D.embed.Texture.EmbedTextureMurPorte)().bitmapData, false, true, MipMapping.PER_PIXEL);
			textureM.correctUV =true;
			
			//Texture de la partir Mur
			var textureMur:TextureMaterial = new TextureMaterial(new (display3D.embed.Texture.EmbedTextureMur)().bitmapData, false, true, MipMapping.PER_PIXEL);
			textureM.correctUV =true;
			//Calcul de la partie mur	
			var meshm:Mesh = new Mesh();
			var v1m:Vertex = meshm.addVertex(point1[0], point1[1],  Mur.hauteur, 0, 0, "v1m");
			var v2m:Vertex = meshm.addVertex(point1[0], point1[1],  Mur.hauteur-200, 0, 1, "v2m");
			var v3m:Vertex = meshm.addVertex(point2[0], point2[1],  Mur.hauteur-200, 1, 1, "v3m");
			var v4m:Vertex = meshm.addVertex(point2[0], point2[1],  Mur.hauteur, 1, 0, "v4m");
			meshm.addQuadFace(v4m,v3m,v2m,v1m, textureM,"faceMur1");
			meshm.addQuadFace(v1m,v2m,v3m,v4m, textureM,"faceMur2");
			meshm.calculateFacesNormals(true);
			meshm.clipping = Clipping.FACE_CLIPPING;
			meshm.sorting = Sorting.DYNAMIC_BSP;
			meshm.calculateBounds();
			
			var meshg:Mesh = new Mesh();
			var v1g:Vertex = meshg.addVertex(point1b[0], point1b[1],  Mur.hauteur, 0, 0, "v1m");
			var v2g:Vertex = meshg.addVertex(point1b[0], point1b[1],  0, 0, 1, "v2m");
			var v3g:Vertex = meshg.addVertex(point1[0], point1[1],  0, 1, 1, "v3m");
			var v4g:Vertex = meshg.addVertex(point1[0], point1[1],  Mur.hauteur, 1, 0, "v4m");
			meshg.addQuadFace(v4g,v3g,v2g,v1g, textureMur,"faceMur1");
			meshg.addQuadFace(v1g,v2g,v3g,v4g, textureMur,"faceMur2");
			meshg.calculateFacesNormals(true);
			meshg.clipping = Clipping.FACE_CLIPPING;
			meshg.sorting = Sorting.DYNAMIC_BSP;
			meshg.calculateBounds();
			
			var meshgg:Mesh = new Mesh();
			var v1gg:Vertex = meshgg.addVertex(point2b[0], point2b[1],  Mur.hauteur, 0, 0, "v1m");
			var v2gg:Vertex = meshgg.addVertex(point2b[0], point2b[1],  0, 0, 1, "v2m");
			var v3gg:Vertex = meshgg.addVertex(point2[0], point2[1],  0, 1, 1, "v3m");
			var v4gg:Vertex = meshgg.addVertex(point2[0], point2[1],  Mur.hauteur, 1, 0, "v4m");
			meshgg.addQuadFace(v4gg,v3gg,v2gg,v1gg, textureMur,"faceMur1");
			meshgg.addQuadFace(v1gg,v2gg,v3gg,v4gg, textureMur,"faceMur2");
			meshgg.calculateFacesNormals(true);
			meshgg.clipping = Clipping.FACE_CLIPPING;
			meshgg.sorting = Sorting.DYNAMIC_BSP;
			meshgg.calculateBounds();
			
			//Calcul de la partie mur direction
			var meshd:Mesh = new Mesh();
			var materialm:FillMaterial = new FillMaterial(0xffffff);
			var v1d:Vertex = meshd.addVertex(point1[0], point1[1],  Mur.hauteur-200, 0, 0, "v1m");
			var v2d:Vertex = meshd.addVertex(point1[0], point1[1],  Mur.hauteur-250, 0, 1, "v2m");
			var v3d:Vertex = meshd.addVertex(point2[0], point2[1],  Mur.hauteur-250, 1, 1, "v3m");
			var v4d:Vertex = meshd.addVertex(point2[0], point2[1],  Mur.hauteur-200, 1, 0, "v4m");
			meshd.addQuadFace(v4d,v3d,v2d,v1d, materialm,"faceMur1");
			meshd.addQuadFace(v1d,v2d,v3d,v4d, materialm,"faceMur2");
			meshd.calculateFacesNormals(true);
			meshd.clipping = Clipping.FACE_CLIPPING;
			meshd.sorting = Sorting.DYNAMIC_BSP;
			meshd.calculateBounds();
			
			//Texture de la porte
			var texture:TextureMaterial = new TextureMaterial(new (display3D.embed.Texture.EmbedTexturePorteCouloir)().bitmapData, false, true, MipMapping.PER_PIXEL);
			texture.correctUV =true;
			
			//Calcul de la partie porte
			var meshp:Mesh = new Mesh();
			var materialp:FillMaterial = new FillMaterial();
			var v1p:Vertex = meshp.addVertex(point1[0], point1[1],  Mur.hauteur-250, 0, 0, "v1p");
			var v2p:Vertex = meshp.addVertex(point1[0], point1[1], 0, 0, 1, "v2p");
			var v3p:Vertex = meshp.addVertex(point2[0], point2[1], 0, 1, 1, "v3p");
			var v4p:Vertex = meshp.addVertex(point2[0], point2[1],  Mur.hauteur-250, 1, 0, "v4p");
			meshp.addQuadFace(v4p,v3p,v2p,v1p, texture,"facePorte1");
			meshp.addQuadFace(v1p,v2p,v3p,v4p, texture,"facePorte2");
			meshp.calculateFacesNormals(true);
			meshp.clipping = Sorting.DYNAMIC_BSP;
			meshp.calculateBounds();
			
			
			scene.addChild(meshm);
			scene.addChild(meshp);
			scene.addChild(meshd);
			scene.addChild(meshg);
			scene.addChild(meshgg);
			_objet3D.push(meshm,meshp,meshd,meshg,meshgg);
		}


		/**
		 * Supprime la transition de la scene
		 * @param scene Conteneur de notre salle3D
		 */
		public function supprimerTransition(scene:Object3DContainer):void
		{
			for each (var objet:Object3D in _objet3D)
			{
				scene.removeChild(objet);
			}
		}

		/**
		 * Identifiant de la transition
		 */
		public function get id():String
		{
			return _id;
		}

		/**
		 * @private
		 */
		public function set id(value:String):void
		{
			_id = value;
		}

		/**
		 * Indique si la transition est chargé ou non
		 */
		public function get charged():Boolean
		{
			return _charged;
		}

		/**
		 * @private
		 */
		public function set charged(value:Boolean):void
		{
			_charged = value;
		}

		/**
		 * Coordonée x du point de transition
		 */
		public function get pointX():*
		{
			return _pointX;
		}

		/**
		 * @private
		 */
		public function set pointX(value:*):void
		{
			_pointX = value;
		}

		/**
		 * Coordonée y du point de transition
		 */
		public function get pointY():*
		{
			return _pointY;
		}

		/**
		 * @private
		 */
		public function set pointY(value:*):void
		{
			_pointY = value;
		}

		/**
		 * Vecteur normailsé du mur qui contient la transition
		 */
		public function get vecteurNormMur():Array
		{
			return _vecteurNormMur;
		}

		/**
		 * @private
		 */
		public function set vecteurNormMur(value:Array):void
		{
			_vecteurNormMur = value;
		}

		/**
		 * Contient tout les objets 3D du sol
		 */
		public function get objet3D():Vector.<Object3D>
		{
			return _objet3D;
		}

		/**
		 * @private
		 */
		public function set objet3D(value:Vector.<Object3D>):void
		{
			_objet3D = value;
		}

		/**
		 * Point de contact 1 qui va lancer le chargement de la salle cible 
		 */
		public function get pointContact():Array
		{
			return _pointContact;
		}

		/**
		 * @private
		 */
		public function set pointContact(value:Array):void
		{
			_pointContact = value;
		}

		/**
		 * Point de contact 2 qui va réactiver le point de contact 1
		 */
		public function get pointContact2():Array
		{
			return _pointContact2;
		}

		/**
		 * @private
		 */
		public function set pointContact2(value:Array):void
		{
			_pointContact2 = value;
		}

		/**
		 * Indique si l'utilisateur a bien traversé la transition
		 */
		public function get entrer():Boolean
		{
			return _entrer;
		}

		/**
		 * @private
		 */
		public function set entrer(value:Boolean):void
		{
			_entrer = value;
		}


	}
}